/*
 * Copyright (C) 2011 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.android.gallery3d.app;

import java.util.ArrayList;

import android.annotation.TargetApi;
import android.app.ActionBar;
import android.app.ActionBar.OnMenuVisibilityListener;
import android.app.ActionBar.OnNavigationListener;
import android.app.Activity;
import android.app.AlertDialog;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.res.Resources;
import android.view.LayoutInflater;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.view.ViewGroup;
import android.widget.BaseAdapter;
import android.widget.ShareActionProvider;
import android.widget.TextView;
import android.widget.TwoLineListItem;

import com.android.gallery3d.R;
import com.android.gallery3d.common.ApiHelper;

public class GalleryActionBar implements OnNavigationListener {
	private static final String TAG = GalleryActionBar.class.getSimpleName();

	private ClusterRunner mClusterRunner;
	private CharSequence[] mTitles;
	private ArrayList<Integer> mActions;
	private Context mContext;
	private LayoutInflater mInflater;
	private AbstractGalleryActivity mActivity;
	private ActionBar mActionBar;
	private int mCurrentIndex;
	private ClusterAdapter mAdapter = new ClusterAdapter();

	private AlbumModeAdapter mAlbumModeAdapter;
	private OnAlbumModeSelectedListener mAlbumModeListener;
	private int mLastAlbumModeSelected;
	private CharSequence[] mAlbumModes;
	/**
	 * 幻灯片视图
	 */
	public static final int ALBUM_FILMSTRIP_MODE_SELECTED = 0;
	/**
	 * 网格视图
	 */
	public static final int ALBUM_GRID_MODE_SELECTED = 1;

	public interface ClusterRunner {
		public void doCluster(int id);
	}

	public interface OnAlbumModeSelectedListener {
		public void onAlbumModeSelected(int mode);
	}

	private static class ActionItem {
		public int action;
		public boolean enabled;
		public boolean visible;
		public int spinnerTitle;
		public int dialogTitle;
		public int clusterBy;

		public ActionItem(int action, boolean applied, boolean enabled,
				int title, int clusterBy) {
			this(action, applied, enabled, title, title, clusterBy);
		}

		public ActionItem(int action, boolean applied, boolean enabled,
				int spinnerTitle, int dialogTitle, int clusterBy) {
			this.action = action;
			this.enabled = enabled;
			this.spinnerTitle = spinnerTitle;
			this.dialogTitle = dialogTitle;
			this.clusterBy = clusterBy;
			this.visible = true;
		}
	}

	private static final ActionItem[] sClusterItems = new ActionItem[] {
			new ActionItem(FilterUtils.CLUSTER_BY_ALBUM, true, false,
					R.string.albums, R.string.group_by_album),
			new ActionItem(FilterUtils.CLUSTER_BY_LOCATION, true, false,
					R.string.locations, R.string.location,
					R.string.group_by_location),
			new ActionItem(FilterUtils.CLUSTER_BY_TIME, true, false,
					R.string.times, R.string.time, R.string.group_by_time),
			new ActionItem(FilterUtils.CLUSTER_BY_FACE, true, false,
					R.string.people, R.string.group_by_faces),
			new ActionItem(FilterUtils.CLUSTER_BY_TAG, true, false,
					R.string.tags, R.string.group_by_tags) };

	private class ClusterAdapter extends BaseAdapter {

		@Override
		public int getCount() {
			return sClusterItems.length;
		}

		@Override
		public Object getItem(int position) {
			return sClusterItems[position];
		}

		@Override
		public long getItemId(int position) {
			return sClusterItems[position].action;
		}

		@Override
		public View getView(int position, View convertView, ViewGroup parent) {
			if (convertView == null) {
				convertView = mInflater.inflate(R.layout.action_bar_text,
						parent, false);
			}
			TextView view = (TextView) convertView;
			view.setText(sClusterItems[position].spinnerTitle);
			return convertView;
		}
	}

	private class AlbumModeAdapter extends BaseAdapter {
		@Override
		public int getCount() {
			return mAlbumModes.length;
		}

		@Override
		public Object getItem(int position) {
			return mAlbumModes[position];
		}

		@Override
		public long getItemId(int position) {
			return position;
		}

		@Override
		public View getView(int position, View convertView, ViewGroup parent) {
			if (convertView == null) {
				convertView = mInflater.inflate(
						R.layout.action_bar_two_line_text, parent, false);
			}
			TwoLineListItem view = (TwoLineListItem) convertView;
			view.getText1().setText(mActionBar.getTitle());
			view.getText2().setText((CharSequence) getItem(position));
			return convertView;
		}

		@Override
		public View getDropDownView(int position, View convertView,
				ViewGroup parent) {
			if (convertView == null) {
				convertView = mInflater.inflate(R.layout.action_bar_text,
						parent, false);
			}
			TextView view = (TextView) convertView;
			view.setText((CharSequence) getItem(position));
			return convertView;
		}
	}

	public static String getClusterByTypeString(Context context, int type) {
		for (ActionItem item : sClusterItems) {
			if (item.action == type) {
				return context.getString(item.clusterBy);
			}
		}
		return null;
	}

	public GalleryActionBar(AbstractGalleryActivity activity) {
		mActionBar = activity.getActionBar();
		mContext = activity.getAndroidContext();
		mActivity = activity;
		mInflater = ((Activity) mActivity).getLayoutInflater();
		mCurrentIndex = 0;
	}

	private void createDialogData() {
		ArrayList<CharSequence> titles = new ArrayList<CharSequence>();
		mActions = new ArrayList<Integer>();
		for (ActionItem item : sClusterItems) {
			if (item.enabled && item.visible) {
				titles.add(mContext.getString(item.dialogTitle));
				mActions.add(item.action);
			}
		}
		mTitles = new CharSequence[titles.size()];
		titles.toArray(mTitles);
	}

	public int getHeight() {
		return mActionBar != null ? mActionBar.getHeight() : 0;
	}

	/**
	 * 根据ID设置ClusterItem是否启用
	 * 
	 * @param id
	 * @param enabled
	 */
	public void setClusterItemEnabled(int id, boolean enabled) {
		Log.d(TAG, "setClusterItemEnabled -- id : " + id + " enabled : "
				+ enabled);
		for (ActionItem item : sClusterItems) {
			if (item.action == id) {
				item.enabled = enabled;
				return;
			}
		}
	}

	/**
	 * 根据ID设置ClusterItem是否可见
	 * 
	 * @param id
	 * @param visible
	 */
	public void setClusterItemVisibility(int id, boolean visible) {
		Log.d(TAG, "setClusterItemVisibility -- id : " + id + " visible : "
				+ visible);
		for (ActionItem item : sClusterItems) {
			if (item.action == id) {
				item.visible = visible;
				return;
			}
		}
	}

	public int getClusterTypeAction() {
		return sClusterItems[mCurrentIndex].action;
	}

	public void enableClusterMenu(int action, ClusterRunner runner) {
		Log.d(TAG, "enableClusterMenu -- action : " + action);
		if (mActionBar != null) {
			// Don't set cluster runner until action bar is ready.
			mClusterRunner = null;
			mActionBar.setListNavigationCallbacks(mAdapter, this);
			mActionBar.setNavigationMode(ActionBar.NAVIGATION_MODE_LIST);
			setSelectedAction(action);
			mClusterRunner = runner;
		}
	}

	// The only use case not to hideMenu in this method is to ensure
	// all elements disappear at the same time when exiting gallery.
	// hideMenu should always be true in all other cases.
	public void disableClusterMenu(boolean hideMenu) {
		if (mActionBar != null) {
			mClusterRunner = null;
			if (hideMenu) {
				mActionBar
						.setNavigationMode(ActionBar.NAVIGATION_MODE_STANDARD);
			}
		}
	}

	public void onConfigurationChanged() {
		if (mActionBar != null && mAlbumModeListener != null) {
			OnAlbumModeSelectedListener listener = mAlbumModeListener;
			enableAlbumModeMenu(mLastAlbumModeSelected, listener);
		}
	}

	public void enableAlbumModeMenu(int selected,
			OnAlbumModeSelectedListener listener) {
		if (mActionBar != null) {
			if (mAlbumModeAdapter == null) {
				// Initialize the album mode options if they haven't been
				// already
				Resources res = mActivity.getResources();
				mAlbumModes = new CharSequence[] {
						res.getString(R.string.switch_photo_filmstrip),
						res.getString(R.string.switch_photo_grid) };
				mAlbumModeAdapter = new AlbumModeAdapter();
			}
			mAlbumModeListener = null;
			mLastAlbumModeSelected = selected;
			mActionBar.setListNavigationCallbacks(mAlbumModeAdapter, this);
			mActionBar.setNavigationMode(ActionBar.NAVIGATION_MODE_LIST);
			mActionBar.setSelectedNavigationItem(selected);
			mAlbumModeListener = listener;
		}
	}

	public void disableAlbumModeMenu(boolean hideMenu) {
		if (mActionBar != null) {
			mAlbumModeListener = null;
			if (hideMenu) {
				mActionBar
						.setNavigationMode(ActionBar.NAVIGATION_MODE_STANDARD);
			}
		}
	}

	public void showClusterDialog(final ClusterRunner clusterRunner) {
		createDialogData();
		final ArrayList<Integer> actions = mActions;
		new AlertDialog.Builder(mContext).setTitle(R.string.group_by)
				.setItems(mTitles, new DialogInterface.OnClickListener() {
					@Override
					public void onClick(DialogInterface dialog, int which) {
						// Need to lock rendering when operations invoked by
						// system UI (main thread) are
						// modifying slot data used in GL thread for rendering.
						mActivity.getGLRoot().lockRenderThread();
						try {
							clusterRunner.doCluster(actions.get(which)
									.intValue());
						} finally {
							mActivity.getGLRoot().unlockRenderThread();
						}
					}
				}).create().show();
	}

	@TargetApi(ApiHelper.VERSION_CODES.ICE_CREAM_SANDWICH)
	private void setHomeButtonEnabled(boolean enabled) {
		if (mActionBar != null)
			mActionBar.setHomeButtonEnabled(enabled);
	}

	public void setDisplayOptions(boolean displayHomeAsUp, boolean showTitle) {
		if (mActionBar == null) {
			return;
		}
		int options = 0;
		if (displayHomeAsUp) {
			options |= ActionBar.DISPLAY_HOME_AS_UP;
		}
		if (showTitle) {
			options |= ActionBar.DISPLAY_SHOW_TITLE;
		}

		mActionBar.setDisplayOptions(options, ActionBar.DISPLAY_HOME_AS_UP
				| ActionBar.DISPLAY_SHOW_TITLE);
		mActionBar.setHomeButtonEnabled(displayHomeAsUp);
	}

	// ----------------------TitleBar start--

	public static final int FLAG_PHOTO = 0;
	public static final int FLAG_ALBUM = 1;

	public void setDisplayOptions(int options) {
		if (mActionBar != null) {
			mActionBar.setDisplayOptions(options);
		}
	}

	public void setDisplayOptions(int options, int mask) {
		if (mActionBar != null) {
			mActionBar.setDisplayOptions(options, mask);
		}
	}

	public void setCustomView(int res) {
		if (mActionBar != null) {
			mActionBar.setCustomView(res);
		}
	}

	public void setCustomView(View view) {
		if (mActionBar != null) {
			mActionBar.setCustomView(view);
		}
	}

	public View getCustomView() {
		if (mActionBar != null) {
			return mActionBar.getCustomView();
		}
		return null;
	}

	public void setDisplayShowCustomEnabled(boolean showCustom) {
		if (mActionBar != null) {
			mActionBar.setDisplayShowCustomEnabled(showCustom);
		}
	}

	// ----------------------TitleBar end--

	public void setTitle(String title) {
		if (mActionBar != null)
			mActionBar.setTitle(title);
	}

	public void setTitle(int titleId) {
		if (mActionBar != null) {
			mActionBar.setTitle(mContext.getString(titleId));
		}
	}

	public void setSubtitle(String title) {
		if (mActionBar != null)
			mActionBar.setSubtitle(title);
	}

	public void show() {
		if (mActionBar != null)
			mActionBar.show();
	}

	public void hide() {
		if (mActionBar != null)
			mActionBar.hide();
	}

	public void addOnMenuVisibilityListener(OnMenuVisibilityListener listener) {
		if (mActionBar != null)
			mActionBar.addOnMenuVisibilityListener(listener);
	}

	public void removeOnMenuVisibilityListener(OnMenuVisibilityListener listener) {
		if (mActionBar != null)
			mActionBar.removeOnMenuVisibilityListener(listener);
	}

	public boolean setSelectedAction(int action) {
		if (mActionBar == null) {
			return false;
		}

		for (int i = 0, n = sClusterItems.length; i < n; i++) {
			ActionItem item = sClusterItems[i];
			if (item.action == action) {
				mActionBar.setSelectedNavigationItem(i);
				mCurrentIndex = i;
				return true;
			}
		}
		return false;
	}

	@Override
	public boolean onNavigationItemSelected(int itemPosition, long itemId) {
		if (itemPosition != mCurrentIndex && mClusterRunner != null
				|| mAlbumModeListener != null) {
			// Need to lock rendering when operations invoked by system UI (main
			// thread) are
			// modifying slot data used in GL thread for rendering.
			mActivity.getGLRoot().lockRenderThread();
			try {
				if (mAlbumModeListener != null) {
					mAlbumModeListener.onAlbumModeSelected(itemPosition);
				} else {
					mClusterRunner
							.doCluster(sClusterItems[itemPosition].action);
				}
			} finally {
				mActivity.getGLRoot().unlockRenderThread();
			}
		}
		return false;
	}

	/*
	 * -------------------------------- PhotoPage ActionBar Menu
	 */
	private Menu mActionBarMenu;
	private ShareActionProvider mSharePanoramaActionProvider;
	private ShareActionProvider mShareActionProvider;
	private Intent mSharePanoramaIntent;
	private Intent mShareIntent;

	public void createActionBarMenu(int menuRes, Menu menu) {
		mActivity.getMenuInflater().inflate(menuRes, menu);
		mActionBarMenu = menu;

		MenuItem item = menu.findItem(R.id.action_share_panorama);
		if (item != null) {
			mSharePanoramaActionProvider = (ShareActionProvider) item
					.getActionProvider();
			mSharePanoramaActionProvider
					.setShareHistoryFileName("panorama_share_history.xml");
			mSharePanoramaActionProvider.setShareIntent(mSharePanoramaIntent);
		}

		item = menu.findItem(R.id.action_share);
		if (item != null) {
			mShareActionProvider = (ShareActionProvider) item
					.getActionProvider();
			mShareActionProvider.setShareHistoryFileName("share_history.xml");
			mShareActionProvider.setShareIntent(mShareIntent);
		}
	}

	public Menu getMenu() {
		return mActionBarMenu;
	}

	public void setShareIntents(Intent sharePanoramaIntent, Intent shareIntent,
			ShareActionProvider.OnShareTargetSelectedListener onShareListener) {
		mSharePanoramaIntent = sharePanoramaIntent;
		if (mSharePanoramaActionProvider != null) {
			mSharePanoramaActionProvider.setShareIntent(sharePanoramaIntent);
		}
		mShareIntent = shareIntent;
		if (mShareActionProvider != null) {
			mShareActionProvider.setShareIntent(shareIntent);
			mShareActionProvider
					.setOnShareTargetSelectedListener(onShareListener);
		}
	}
}
